home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 076-100 / disk_085 / csh / comm2.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  13KB  |  593 lines
  1.  
  2. /*
  3.  * COMM2.C
  4.  *
  5.  * (c)1986 Matthew Dillon     9 October 1986
  6.  *
  7.  * version 2.06M (Manx Version and Additions) by Steve Drew 28-May-87
  8.  *
  9.  */
  10.  
  11. #include "shell.h"
  12. typedef struct FileInfoBlock FIB;
  13.  
  14. /* Casting conveniences */
  15. #define BPTR_TO_C(strtag, var)    ((struct strtag *)(BADDR( (ULONG) var)))
  16. #define PROC(task)        ((struct Process *)task)
  17. #define ROOTNODE        ((struct RootNode *)DOSBase->dl_Root)
  18. #define CLI(proc)        (BPTR_TO_C(CommandLineInterface, proc->pr_CLI))
  19.  
  20. /* Externs */
  21. extern int has_wild;            /* flag set if any arg has a ? or * */
  22. extern struct DosLibrary *DOSBase;    /* dos library base pointer         */
  23.  
  24. /* globals */
  25. int cp_update;
  26. int cp_date;
  27.  
  28. do_abortline()
  29. {
  30.    Exec_abortline = 1;
  31.    return (0);
  32. }
  33.  
  34. do_return()
  35. {
  36.    Exec_abortline = 1;
  37.    if (Src_stack) {
  38.       fseek (Src_base[Src_stack - 1], 0, 2);
  39.       return ((ac < 2) ? 0 : atoi(av[1]));
  40.    } else {
  41.       main_exit ((ac < 2) ? 0 : atoi(av[1]));
  42.    }
  43. }
  44.  
  45. /*
  46.  * STRHEAD
  47.  *
  48.  * place a string into a variable removing everything after and including
  49.  * the 'break' character or until a space is found in the string.
  50.  *
  51.  * strhead varname breakchar string
  52.  *
  53.  */
  54.  
  55. do_strhead()
  56. {
  57.    register char *str = av[3];
  58.    char bc = *av[2];
  59.  
  60.    while (*str && *str != bc)
  61.       ++str;
  62.    *str = '\0';
  63.    set_var (LEVEL_SET, av[1], av[3]);
  64.    return (0);
  65. }
  66.  
  67. do_strtail()
  68. {
  69.    register char *str = av[3];
  70.    char bc = *av[2];
  71.  
  72.    while (*str && *str != bc)
  73.       ++str;
  74.    if (*str)
  75.       ++str;
  76.    set_var (LEVEL_SET, av[1], str);
  77.    return (0);
  78. }
  79.  
  80.  
  81.  
  82. /*
  83.  * if A < B   <, >, =, <=, >=, !=, where A and B are either:
  84.  * nothing
  85.  * a string
  86.  * a value (begins w/ number)
  87.  */
  88.  
  89. do_if(garbage, com)
  90. char *garbage;
  91. {
  92.    char *v1, *v2, *v3, result, num;
  93.    int n1, n2;
  94.  
  95.    switch (com) {
  96.    case 0:
  97.       if (If_stack && If_base[If_stack - 1]) {
  98.      If_base[If_stack++] = 1;
  99.      break;
  100.       }
  101.       result = num = 0;
  102.       if (ac <= 2) {       /* if $var; */
  103.      if (ac == 1 || strlen(av[1]) == 0 || (strlen(av[1]) == 1 && *av[1] == ' '))
  104.         goto do_result;
  105.      result = 1;
  106.      goto do_result;
  107.       }
  108.       if (ac != 4) {
  109.      ierror(NULL, 500);
  110.      break;
  111.       }
  112.       v1 = av[1]; v2 = av[2]; v3 = av[3];
  113.       while (*v1 == ' ')
  114.      ++v1;
  115.       while (*v2 == ' ')
  116.      ++v2;
  117.       while (*v3 == ' ')
  118.      ++v3;
  119.       if (*v1 >= '0' && *v1 <= '9') {
  120.      num = 1;
  121.      n1 = atoi(v1);
  122.      n2 = atoi(v3);
  123.       }
  124.       while (*v2) {
  125.      switch (*v2++) {
  126.      case '>':
  127.         result |= (num) ? (n1 >  n2) : (strcmp(v1, v3) > 0);
  128.         break;
  129.      case '<':
  130.         result |= (num) ? (n1 <  n2) : (strcmp(v1, v3) < 0);
  131.         break;
  132.      case '=':
  133.         result |= (num) ? (n1 == n2) : (strcmp(v1, v3) ==0);
  134.         break;
  135.      default:
  136.         ierror (NULL, 503);
  137.         break;
  138.      }
  139.       }
  140. do_result:
  141.       If_base[If_stack++] = !result;
  142.       break;
  143.    case 1:
  144.       if (If_stack > 1 && If_base[If_stack - 2])
  145.      break;
  146.       if (If_stack)
  147.      If_base[If_stack - 1] ^= 1;
  148.       break;
  149.    case 2:
  150.       if (If_stack)
  151.      --If_stack;
  152.       break;
  153.    }
  154.    disable = (If_stack) ? If_base[If_stack - 1] : 0;
  155.    if (If_stack >= MAXIF) {
  156.       fprintf(stderr,"If's too deep\n");
  157.       disable = If_stack = 0;
  158.       return(-1);
  159.       }
  160.    return (0);
  161. }
  162.  
  163. do_label()
  164. {
  165.    char aseek[32];
  166.  
  167.    if (Src_stack == 0) {
  168.       ierror (NULL, 502);
  169.       return (-1);
  170.    }
  171.    sprintf (aseek, "%ld %d", Src_pos[Src_stack-1], If_stack);
  172.    set_var (LEVEL_LABEL + Src_stack - 1, av[1], aseek);
  173.    return (0);
  174. }
  175.  
  176. do_goto()
  177. {
  178.    int new;
  179.    long pos;
  180.    char *lab;
  181.  
  182.    if (Src_stack == 0) {
  183.       ierror (NULL, 502);
  184.    } else {
  185.       lab = get_var (LEVEL_LABEL + Src_stack - 1, av[1]);
  186.       if (lab == NULL) {
  187.      ierror (NULL, 501);
  188.       } else {
  189.      pos = atoi(lab);
  190.      fseek (Src_base[Src_stack - 1], pos, 0);
  191.      Src_pos[Src_stack - 1] = pos;
  192.      new = atoi(next_word(lab));
  193.      for (; If_stack < new; ++If_stack)
  194.         If_base[If_stack] = 0;
  195.      If_stack = new;
  196.       }
  197.    }
  198.    Exec_abortline = 1;
  199.    return (0);        /* Don't execute rest of this line */
  200. }
  201.  
  202.  
  203. do_inc(garbage, com)
  204. char *garbage;
  205. {
  206.    char *var;
  207.    char num[32];
  208.  
  209.    if (ac == 3)
  210.       com = atoi(av[2]);
  211.    var = get_var (LEVEL_SET, av[1]);
  212.    if (var) {
  213.       sprintf (num, "%d", atoi(var)+com);
  214.       set_var (LEVEL_SET, av[1], num);
  215.    }
  216.    return (0);
  217. }
  218.  
  219. do_input()
  220. {
  221.    char in[256];
  222.  
  223.    if ((gets(in)) != 0)
  224.       set_var (LEVEL_SET, av[1], in);
  225.    return (0);
  226. }
  227.  
  228. do_ver()
  229. {
  230.    puts (VERSION);
  231.    return (0);
  232. }
  233.  
  234.  
  235. do_ps()
  236. {
  237.     /* this code fragment based on ps.c command by Dewi Williams */
  238.  
  239.     register ULONG     *tt;        /* References TaskArray        */
  240.     register int     count;        /* loop variable        */
  241.     register UBYTE     *port;        /* msgport & ptr arith        */
  242.     register struct Task *task;    /* EXEC descriptor        */
  243.     char         strbuf[64];   /* scratch for btocstr()           */
  244.     char         *btocstr();    /* BCPL BSTR to ASCIIZ        */
  245.  
  246.     tt = (unsigned long *)(BADDR(ROOTNODE->rn_TaskArray));
  247.  
  248.     printf("Proc Command Name      CLI Type    Pri.  Address  Directory\n");
  249.     Forbid();        /* need linked list consistency */
  250.  
  251.     for (count = 1; count <= (int)tt[0] ; count++) {/* or just assume 20?*/
  252.         if (tt[count] == 0) continue;        /* nobody home */
  253.  
  254.         /* Start by pulling out MsgPort addresses from the TaskArray
  255.          * area. By making unwarranted assumptions about the layout
  256.          * of Process and Task structures, we can derive these
  257.          * descriptors. Every task has an associated process, since
  258.          * this loop drives off a CLI data area.
  259.          */
  260.  
  261.         port = (UBYTE *)tt[count];
  262.         task = (struct Task *)(port - sizeof(struct Task));
  263.  
  264.         /* Sanity check just in case */
  265.         if (PROC(task)->pr_TaskNum == 0 || PROC(task)->pr_CLI == 0)
  266.             continue;        /* or complain? */
  267.  
  268.             btocstr(CLI(PROC(task))->cli_CommandName, strbuf);
  269.             printf("%2d   %-21s",count,strbuf);
  270.             strcpy(strbuf,task->tc_Node.ln_Name);
  271.             strbuf[11] = '\0';
  272.             printf("%-11s",strbuf);
  273.             printf(" %3d  %8lx  %s\n",
  274.                task->tc_Node.ln_Pri,task,
  275.                btocstr(CLI(PROC(task))->cli_SetName, strbuf));
  276.     }
  277.     Permit();        /* outside critical region */
  278.     return(0);
  279. }
  280.  
  281.  
  282. char *
  283. btocstr(b, buf)
  284. ULONG    b;
  285. char    *buf;
  286. {
  287.     register char    *s;
  288.  
  289.     s = (char *)BADDR(b);    /* Shift & get length-prefixed str */
  290.     movmem(s +1, buf, s[0]);
  291.     buf[s[0]] = '\0';
  292.     return buf;
  293. }
  294.  
  295.  
  296. /*
  297.  * CP [-d] [-u] file file
  298.  * CP [-d] [-u] file file file... destdir
  299.  * CP [-r][-u][-d] dir dir dir... destdir
  300.  */
  301.  
  302. char *errstr;           /* let's be alittle more informative */
  303. do_copy()
  304. {
  305.    register int recur, ierr;
  306.    register char *destname;
  307.    register char destisdir;
  308.    register FIB *fib;
  309.    int i,opt;
  310.  
  311.    errstr = "";
  312.    ierr = 0;
  313.  
  314.    fib = (FIB *)AllocMem((long)sizeof(FIB), MEMF_PUBLIC);
  315.  
  316.    opt = get_opt("rud",&i);
  317.    recur     = (opt & 0x01);
  318.    cp_update = (opt & 0x02);
  319.    cp_date   = (!(opt & 0x04)); /* the default is keep orignal file date */
  320.  
  321.    destname = av[ac - 1];
  322.  
  323.    if (ac < i + 2) {
  324.       ierr = 500;
  325.       goto done;
  326.    }
  327.  
  328.    destisdir = isdir(destname);
  329.    if (ac > i + 2 && !destisdir) {
  330.       ierr = 507;
  331.       goto done;
  332.    }
  333.  
  334.    /*
  335.     * copy set:                   reduce to:
  336.     *     file to file              file to file
  337.     *     dir  to file (NOT ALLOWED)
  338.     *     file to dir              dir to dir
  339.     *     dir  to dir              dir to dir
  340.     *
  341.     */
  342.  
  343.    for (; i < ac - 1; ++i) {
  344.       short srcisdir = isdir(av[i]);
  345.       if (srcisdir && has_wild && (ac >2)) /* hack to stop dir's from */
  346.       continue;               /* getting copied if specified */
  347.                        /* from wild expansion */
  348.       if (CHECKBREAK())
  349.      break;
  350.       if (srcisdir) {
  351.      struct FileLock *srcdir, *destdir;
  352.      if (!destisdir) {
  353.         if (destdir = (struct FileLock *)Lock(destname, ACCESS_READ)) {
  354.            UnLock(destdir);
  355.            ierr = 507;          /* disallow dir to file */
  356.            goto done;
  357.         }
  358.         if (destdir = (struct FileLock *)CreateDir(destname))
  359.            UnLock(destdir);
  360.         destisdir = 1;
  361.      }
  362.      if (!(destdir = (struct FileLock *)Lock(destname, ACCESS_READ))) {
  363.         ierr = 205;
  364.         errstr = destname;
  365.         goto done;
  366.      }
  367.      if (!(srcdir = (struct FileLock *)Lock(av[i], ACCESS_READ))) {
  368.         ierr = 205;
  369.         errstr = av[i];
  370.         UnLock(destdir);
  371.         goto done;
  372.      }
  373.      ierr = copydir(srcdir, destdir, recur);
  374.      UnLock(srcdir);
  375.      UnLock(destdir);
  376.      if (ierr)
  377.         break;
  378.       } else {                /* FILE to DIR,   FILE to FILE   */
  379.      struct FileLock *destdir, *srcdir, *tmp;
  380.      char *destfilename;
  381.  
  382.      srcdir = (struct FileLock *)(Myprocess->pr_CurrentDir);
  383.  
  384.      if ((tmp = (struct FileLock *)Lock(av[i], ACCESS_READ)) == NULL || !Examine(tmp,fib)){
  385.         if (tmp) UnLock(tmp);
  386.         ierr = 205;
  387.         errstr = av[i];
  388.         goto done;
  389.      }
  390.      UnLock(tmp);
  391.      if (destisdir) {
  392.         destdir = (struct FileLock *)Lock(destname, ACCESS_READ);
  393.         destfilename = fib->fib_FileName;
  394.      } else {
  395.         destdir = srcdir;
  396.         destfilename = destname;
  397.      }
  398.      printf(" %s..",av[i]);
  399.      fflush(stdout);
  400.      ierr = copyfile(av[i], srcdir, destfilename, destdir);
  401.      if (destisdir)
  402.         UnLock(destdir);
  403.      if (ierr)
  404.         break;
  405.       }
  406.    }
  407. done:
  408.    FreeMem(fib, (long)sizeof(*fib));
  409.    if (ierr) {
  410.       ierror(errstr, ierr);
  411.       return(20);
  412.    }
  413.    return(0);
  414. }
  415.  
  416.  
  417. copydir(srcdir, destdir, recur)
  418. register struct FileLock *srcdir, *destdir;
  419. {
  420.    struct FileLock *cwd;
  421.    register FIB *srcfib;
  422.    register struct FileLock *destlock, *srclock;
  423.    int ierr;
  424.    static int level;
  425.  
  426.    level++;
  427.    ierr = 0;
  428.    srcfib = (FIB *)AllocMem((long)sizeof(FIB), MEMF_PUBLIC);
  429.    if (Examine(srcdir, srcfib)) {
  430.       while (ExNext(srcdir, srcfib)) {
  431.      if (CHECKBREAK())
  432.         break;
  433.      if (srcfib->fib_DirEntryType < 0) {
  434.         printf("%*s%s..",(level-1) * 6," ",srcfib->fib_FileName);
  435.         fflush(stdout);
  436.         ierr = copyfile(srcfib->fib_FileName,srcdir,srcfib->fib_FileName,destdir);
  437.         if (ierr)
  438.            break;
  439.      } else {
  440.         if (recur) {
  441.            cwd = (struct FileLock *)CurrentDir(srcdir);
  442.            if (srclock = (struct FileLock *)Lock(srcfib->fib_FileName, ACCESS_READ)) {
  443.           CurrentDir(destdir);
  444.           if (!(destlock = (struct FileLock *)
  445.                 Lock(srcfib->fib_FileName))) {
  446.              destlock = (struct FileLock *)CreateDir(srcfib->fib_FileName);
  447.              printf("%*s%s (Dir)....[Created]\n",(level-1) * 6,
  448.                 " ",srcfib->fib_FileName);
  449.  
  450.              /* UnLock and re Lock if newly created dir
  451.                 for file_date() to work properly.
  452.              */   
  453.               if (destlock) UnLock(destlock);
  454.               destlock = (struct FileLock *)Lock(srcfib->fib_FileName);             
  455.           }
  456.           else
  457.              printf("%*s%s (Dir)\n",(level-1) * 6," ",srcfib->fib_FileName);
  458.           if (destlock) {
  459.              ierr = copydir(srclock, destlock, recur);
  460.              UnLock(destlock);
  461.           } else {
  462.              ierr = (int)((long)IoErr());
  463.           }
  464.           UnLock(srclock);
  465.            } else {
  466.           ierr = (int)((long)IoErr());
  467.            }
  468.            CurrentDir(cwd);
  469.            if (ierr)
  470.           break;
  471.         }
  472.      }
  473.       }
  474.    } else {
  475.       ierr = (int)((long)IoErr());
  476.    }
  477.    --level;
  478.    FreeMem(srcfib, (long)sizeof(FIB));
  479.    return(ierr);
  480. }
  481.  
  482.  
  483. copyfile(srcname, srcdir, destname, destdir)
  484. char *srcname, *destname;
  485. struct FileLock *srcdir, *destdir;
  486. {
  487.    struct FileLock *cwd;
  488.    struct FileHandle *f1, *f2;
  489.    struct DateStamp *ds;
  490.    long i;
  491.    int stat,ierr;
  492.    char *buf;
  493.    struct DPTR        *dp, *dps = NULL;
  494.  
  495.    buf = (char *)AllocMem(8192L, MEMF_PUBLIC|MEMF_CLEAR);
  496.    if (buf == NULL) {
  497.       ierr = 103;
  498.       goto fail;
  499.    }
  500.  
  501.    ierr = 0;
  502.    cwd = (struct FileLock *)CurrentDir(srcdir);
  503.    f1 = Open(srcname, MODE_OLDFILE);
  504.    if (f1 == NULL) {
  505.       errstr = srcname;
  506.       ierr = 205;
  507.       goto fail;
  508.    }
  509.    dps = dopen(srcname,&stat);
  510.    ds = &dps->fib->fib_Date;
  511.    CurrentDir(destdir);
  512.    if (cp_update  && (dp = dopen (destname, &stat))) {
  513.     long desttime,srctime;
  514.     struct DateStamp *dd;
  515.  
  516.     dd = &dp->fib->fib_Date;
  517.     desttime = dd->ds_Days * 24 * 60 * 60 + dd->ds_Minute * 60 +
  518.                        dd->ds_Tick/TICKS_PER_SECOND;
  519.     srctime     = ds->ds_Days * 24 * 60 * 60 + ds->ds_Minute * 60 +
  520.                        ds->ds_Tick/TICKS_PER_SECOND;
  521.  
  522.     if (srctime <= desttime &&
  523.       !strcmp(dps->fib->fib_FileName,dp->fib->fib_FileName)) {
  524.         dclose(dp);
  525.         Close(f1);
  526.         printf("..not newer\n");
  527.         goto fail;
  528.     }
  529.     dclose(dp);
  530.    }
  531.    f2 = Open(destname, MODE_NEWFILE);
  532.    if (f2 == NULL) {
  533.       Close(f1);
  534.       ierr = (int)((long)IoErr());
  535.       errstr = destname;
  536.       goto fail;
  537.    }
  538.    while (i = Read(f1, buf, 8192L))
  539.       if (Write(f2, buf, i) != i) {
  540.      ierr = (int)((long)IoErr());
  541.      break;
  542.       }
  543.    Close(f2);
  544.    Close(f1);
  545.    if (!ierr)  {
  546. #ifdef AZTEC_C
  547.       if (cp_date) file_date(ds,destname);
  548. #endif
  549.       printf("..copied\n");
  550.    }
  551.    else {
  552.       DeleteFile(destname);
  553.       printf("..Not copied..");
  554.    }
  555. fail:
  556.    dclose(dps);
  557.    if (buf)
  558.       FreeMem(buf, 8192L);
  559.    CurrentDir(cwd);
  560.    return(ierr);
  561. }
  562.  
  563. #ifdef AZTEC_C         /* since 3.20a did'nt have dos_packet() */
  564.  
  565. file_date(date,name)
  566. struct DateStamp *date;
  567. char *name;
  568. {
  569.     UBYTE *ptr;
  570.     struct MsgPort *task;
  571.     struct FileLock *dirlock;
  572.     struct DPTR *tmp; 
  573.     int stat;
  574.     long ret, dos_packet();
  575.  
  576.     if (!(task = (struct MsgPort *)DeviceProc(name)))
  577.     return(1);
  578.     if (tmp = dopen(name, &stat)) {
  579.     dirlock = (struct FileLock *)ParentDir(tmp->lock);
  580.     ptr = (UBYTE *)AllocMem(64L,MEMF_PUBLIC);
  581.     strcpy((ptr + 1),tmp->fib->fib_FileName);
  582.     *ptr = strlen(tmp->fib->fib_FileName);
  583.     dclose(tmp);
  584.     ret = dos_packet(task,34L,NULL,dirlock,
  585.                  (ULONG)&ptr[0] >> 2L,date);
  586.     FreeMem(ptr,64L);
  587.     UnLock(dirlock);
  588.     }
  589. }
  590.  
  591. #endif
  592.  
  593.